%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% vim:enc=utf-8:ts=5:sw=5:et:ff=unix:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Buscas e Substituições}\label{cha:Buscas e substituições}

Para fazer uma busca, certifique-se de que está em modo normal,
pressione ``/'' e digite a expressão a ser procurada. \\


Para encontrar a primeira ocorrência de ``foo'' no texto:

\begin{verbatim}
     /foo
\end{verbatim}

Para repetir a busca basta pressionar a tecla ``\verb+n+'' e para
repetir a busca em sentido oposto ``\verb+N+''.

\begin{verbatim}
     /teste/+3
\end{verbatim}

Posiciona o cursor três linhas após a ocorrência da palavra ``teste'' \\

\begin{verbatim}
     /\<casa\>
\end{verbatim}

A busca acima localiza `{\tt casa}' mas não `{\tt casamento}'. Em expressões
regulares, \verb|\<| e \verb|\>| são representadas por \verb|\b|, que representa, por sua vez, borda
de palavras. Ou seja, `{\tt casa,}`, `{\tt casa!}` seriam localizado, visto que sinais
de pontuação não fazem parte da palavra.


\section{Usando ``Expressões Regulares'' em buscas}
\label{Usando ``Expressões Regulares'' em buscas}
\index{expressões regulares!buscas}
\vimhelp{regex, pattern}

\begin{verbatim}
     / ........... inicia uma busca (modo normal)
     \%x69 ....... código da letra `i'
     /\%x69 ...... localiza a letra `i' - hexadecimal 069
     \d .......... localiza números
     [3-8] ....... localiza números de 3 até 8
     ^ ........... começo de linha
     $ ........... final de linha
     \+ .......... um ou mais
     /^\d\+$ ..... localiza somente dígitos
     /\r$ ........ localiza linhas terminadas com ^M
     /^\s*$ ...... localiza linhas vazias ou contendo apenas espaços
     /^\t\+ ...... localiza linhas que iniciam com tabs
     \s .......... localiza espaços
     /\s\+$ ...... localiza espaços no final da linha
\end{verbatim}

\subsection{Evitando escapes ao usar Expressões regulares}

O Vim possui um modo chamado ``{\em very magic}'' para uso em expressões
regulares que evita o uso excessivo de escapes, alternativas etc. Usando apenas
uma opção: veja ``\verb+:h /\v+''.

Em um trecho com dígitos + texto + dígitos
no qual se deseja manter só as letras.

\begin{verbatim}
     12345aaa678
     12345bbb678
     12345aac678
\end{verbatim}

Sem a opção ``{\em very magic}'' faríamos:

\begin{verbatim}
     :%s/\d\{5\}\(\D\+\)\d\{3\}/\1/
\end{verbatim}

Já com a opção ``{\em very magic}'' ``\verb+\v+'' usa-se bem menos escapes:

\begin{verbatim}
     :%s/\v\d{5}(\D+)\d{3}/\1/

     " explicação do comando acima
     : ......... comando
     % ......... em todo arquivo
     s ......... substitua
     / ......... inicia padrão de busca
     \v ........ use very magic mode
     \d ........ dígitos
     {5} ....... 5 vezes 
     ( ........ inicia um grupo
     \D ........ seguido de não dígitos
     )  ........ fecha um grupo     
     + ......... uma ou mais vezes
     \d ........ novamente dígitos
     {3} ....... três vezes 
     / ......... inicio da substituição
     \1 ........ referencia o grupo 1
\end{verbatim}

Analisando o exemplo anterior, a linha de raciocínio foi a de ``manter o texto entre os
dígitos'', o que pode ser traduzido, em uma outra forma de raciocínio, como ``remover os
dígitos''.

\begin{verbatim}
     :%s/\d//g

     " explicação do comando acima
     % ......... em todo arquivo
     s ......... substitua
     / ......... inicia padrão de busca
     \d ........ ao encontrar um dígito
     / ......... subtituir por
     vazio ..... exato, substituir por vazio
     /g ........ a expressão se torna gulosa
\end{verbatim}

Por guloso - \verb|/g| - se entende que ele pode e deve tentar achar mais de uma ocorrência
do padrão de busca na mesma linha. Caso não seja gulosa, a expressão irá apenas casar com a
primeira ocorrência em cada linha.

\subsubsection{Classes {\em POSIX} para uso em Expressões Regulares}

Ao fazermos substituições em textos poderemos nos deparar com
erros, pois [a-z] não inclui caracteres acentuados, as classes
{\em POSIX} são a solução para este problema, pois adequam o
sistema ao idioma local, esta é a mágica implementada por estas classes.

\begin{verbatim}
     [:lower:] ...... letras minúsculas incluindo acentos
     [:upper:] ...... letras maiúsculas incluindo acentos
     [:punct:] ...... ponto, virgula, colchete, etc
\end{verbatim}

Para usar estas classes fazemos:

\begin{verbatim}
     :%s/[[:lower:]]/\U&/g

     Explicando o comando acima:
     : ....... modo de comando
     % ....... em todo o arquivo atual
     s ....... substitua
     / ....... inicia o padrão a ser buscado
     [ ....... inicia um grupo
     [: ...... inicia uma classe POSIX
     lower ... letras minúsculas
     :] ...... termina a classe POSIX
     ] ....... termina o grupo
     / ....... inicia substituição
     \U ...... para maiúsculo
     & ....... correponde ao que foi buscado
\end{verbatim}

Nem todas as classes {\em POSIX} conseguem pegar caracteres
acentuados, portanto deve-se habilitar o destaque colorido para
buscas usando:

\begin{verbatim}
     :set hlsearch .... destaque colorido para buscas
     :set incsearch ... busca incremental
\end{verbatim}

Dessa forma podemos testar nossas buscas antes de fazer
uma substituição.


Para aprender mais sobre Expressões Regulares leia:

\begin{itemize}
  \item \href{http://guia-er.sourceforge.net}{Guia sobre Espressões Regulares}~\cite{JargasRegex}
  \item {\tt :help regex}
  \item {\tt :help pattern}
\end{itemize}

{\Large \ding{45}} Uma forma rápida para encontrar a próxima ocorrência de uma
palavra sob o cursor é teclar `\verb|*|'. Para encontrar uma ocorrência
anterior da palavra sob o cursor, existe o \verb|#| (em ambos os casos o cursor
deve estar posicionado sobre a palavra que deseja procurar). As duas opções
citadas localizam apenas se a palavra corresponder totalmente ao padrão sob o
cursor, pode-se bucar por trechos de palavras que façam parte de palavras
maiores usando-se `\verb+g*+'.  Pode-se ainda exibir ``dentro do contexto''
todas as ocorrências de uma palavra sob o cursor usando-se o seguinte atalho em
modo normal:

\begin{verbatim}
     [ Shift-i
\end{verbatim}

\section{Destacando padrões}
\label{sec:Destacando padrões}
\vimhelp{\%>}

Você pode destacar linhas com mais de 30 caracteres assim:

\begin{verbatim}
     :match ErrorMsg /\%>30v/ . destaca linhas maiores que 30 caracteres
     :match none .............. remove o destaque
\end{verbatim}

\section{Inserindo linha antes e depois}

Suponha que se queira um comando, considere ``\verb|,t|'', que faça com que a
linha indentada corrente passe a ter uma linha em branco antes e depois; isto
pode ser obtido pelo seguinte mapeamento:

\begin{verbatim}
     :map ,t <Esc>:.s/^\(\s\+\)\(.*\)/\r\1\2\r/g<cr>
\end{verbatim}

Explicando:

\begin{verbatim}
     : ................ entra no modo de comando
     map ,t ........... mapeia ,t para a função desejada
     <Esc> ............ ao executar sai do modo de inserção
     s/isto/aquilo/g .. substitui isto por aquilo
     : ................ inicia o modo de comando
     . ................ na linha corrente
     s ................ substitua
     ^ ................ começo de linha
     \s\+ ............. um espaço ou mais (barras são escapes)
     .* ............... qualquer coisa depois
     \(grupo\) ........ agrupo para referenciar com \1
     \1 ............... repete na substituição o grupo 1
     \r ............... insere uma quebra de linha
     g ................ em todas as ocorrências da linha
     <cr> ............. Enter
\end{verbatim}

\section{Obtendo informações do arquivo}

\begin{verbatim}
     ga ............. mostra o código do caractere em decimal hexa e octal
     ^g ............. mostra o caminho e o nome do arquivo
     g^g ............ mostra estatísticas detalhadas do arquivo
\end{verbatim}

Obs: O código do caractere pode ser usado para substituições,
especialmente em se tratando de caracteres de controle como tabulações
``\verb|^I|'' ou final de linha DOS/Windows ``\verb|\%x0d|''. Você pode apagar os
caracteres de final de linha Dos/Windows usando uma simples
substituição, veja mais adiante:

\begin{verbatim}
     :%s/\%x0d//g
\end{verbatim}

Uma forma mais prática de substituir o terminador de linha DOS para o
terminador de linha Unix:

\begin{verbatim}
    :set ff=unix
    :w
\end{verbatim}

Na seção \ref{cha:Como editar preferências no Vim}
página~\pageref{cha:Como editar preferências no Vim}
há um código para a barra de
status que faz com que a mesma exiba o código do caractere sob o cursor na
seção \ref{Função para barra de status}. {\Large {\ding{45}}} O caractere de final de linha
do Windows/DOS pode ser inserido com a seguinte combinação de teclas:

\begin{verbatim}
     i ............ entra em modo de inserção
     <INSERT> ..... entra em modo de inserção
     Ctrl-v Ctrl-m  insere o simbolo ^M (terminador de linha DOS)
\end{verbatim}

\section{Trabalhando com registradores}
\label{Trabalhando com registradores}

Pode-se guardar trechos do que foi copiado ou apagado para
registros distintos (área de transferência múltipla).
Os registros são indicados por aspas seguido por uma letra.
Exemplos: {\tt "a}, {\tt "b}, {\tt "c}, etc.


Como copiar o texto para um registrador? É simples: basta especificar
o nome do registrador antes:

\begin{verbatim}
     "add ... apaga linha para o registrador a
     "bdd ... apaga linha para o registrador b
     "ap .... cola" o conteúdo do registrador a
     "bp .... cola" o conteúdo do registrador b
     "x3dd .. apaga 3 linhas para o registrador ``x''
     "ayy  .. copia linha para o registrador `a'
     "a3yy .. copia 3 linhas para o registrador `a'
     "ayw  .. copia uma palavra para o registrador `a'
     "a3yw .. copia 3 palavras para o registrador `a'
\end{verbatim}

No ``modo de inserção'', como visto anteriormente, pode-se usar um atalho
para colar rapidamente o conteúdo de um registrador.

\begin{verbatim}
     Ctrl-r (registro)
\end{verbatim}

Para colar o conteúdo do registrador `{\tt a}'

\begin{verbatim}
     Ctrl-r a
\end{verbatim}

Para copiar a linha atual para a área de transferência

\begin{verbatim}
     "+yy
\end{verbatim}

Para colar da área de transferência

\begin{verbatim}
     "+p
\end{verbatim}

Para copiar o arquivo atual para a área de transferência ``{\em clipboard}'':

\begin{verbatim}
     :%y+
\end{verbatim}

\section{Edições complexas }
\label{Edições complexas }

Trocando palavras de lugar: Posiciona-se o cursor no espaço antes da 1ª palavra e digita-se:

\begin{verbatim}
     deep
\end{verbatim}

Trocando letras de lugar:

\begin{verbatim}
     xp .... com a letra seguinte
     xh[p .. com a letra anterior
\end{verbatim}

Trocando linhas de lugar:

\begin{verbatim}
     ddp ... com a linha de baixo
     ddkP .. com a linha de cima
\end{verbatim}

Tornando todo o texto maiúsculo

\begin{verbatim}
     gggUG
     ggVGU
\end{verbatim}

\section{Indentando }
\index{indentação}

\begin{verbatim}
     >> ..... Indenta a linha atual
     ^t ..... Indenta a linha atual em modo de inserção
     ^d ..... Remove indentação em modo de inserção
     >ip .... indenta o parágrafo atual
\end{verbatim}

\section{Corrigindo a indentação de códigos}
\label{Corrigindo a indentação de códigos}

Selecione o bloco de código, por exemplo

\begin{verbatim}
     vip  ..... visual ``inner paragraph'' (selecione este parágrafo)
     =  ....... corrige a indentação do bloco de texto selecionado
     ggVG= .... corrige a identação do arquivo inteiro
\end{verbatim}

\section{Usando o File Explorer}
\label{Usando o file explorer}
O Vim navega na árvore de diretórios com o comando

\begin{verbatim}
     vim .
\end{verbatim}

Use o `{\tt j}' para descer e o `{\tt k}' para subir ou {\tt Enter} para editar o
arquivo selecionado. {\Large \ding{45}}  Pressionando {\tt F1} ao abrir o
FileExplorer do Vim, você encontra dicas adicionais sobre este modo de
operação do Vim.

\section{Selecionando ou deletando conteúdo de tags HTML}
\label{Selecionando ou deletando conteúdo de tags html}

\begin{verbatim}
     <tag> conteúdo da tag </tag>
     basta usar (em modo normal) as teclas
     vit ............... visual `inner tag | esta tag'
\end{verbatim}

Este recurso também funciona com parênteses

\begin{verbatim}
     vi( ..... visual select
     vi" ..... visual select
     di( ..... delete inner (, ou seja, seu conteúdo
\end{verbatim}


\section{Substituições }
\label{Substituições }

Para fazer uma busca, certifique-se de que está em modo normal, em
seguida digite use o comando `{\tt s}', conforme será explicado.

Para substituir ``foo'' por ``bar'' na linha atual:

\begin{verbatim}
     :s/foo/bar
\end{verbatim}

Para substituir ``foo'' por ``bar'' da primeira à décima linha do arquivo:

\begin{verbatim}
     :1,10 s/foo/bar
\end{verbatim}

Para substituir ``foo'' por ``bar'' da primeira à última linha do arquivo:

\begin{verbatim}
     :1,$ s/foo/bar
\end{verbatim}

Ou simplesmente:

\begin{verbatim}
     :% s/foo/bar
\end{verbatim}

\begin{verbatim}
     $ ... significa para o Vim final do arquivo
     % ... representa o arquivo atual
\end{verbatim}

O comando `{\tt s}' possui muitas opções que modificam seu comportamento.

\section{Exemplos }
\label{Exemplos }

Busca usando alternativas:

\begin{verbatim}
     /end\(if\|while\|for\)
\end{verbatim}

Buscará `{\tt if}', `{\tt while}' e `{\tt for}'.  Observe que é necessário `escapar' os
caracteres \verb|\(|, \verb|\|| e \verb|\)|, caso contrário eles serão
interpretados como caracteres comuns.

Quebra de linha

\begin{verbatim}
     /quebra\nde linha
\end{verbatim}

Ignorando maiúsculas e minúsculas

\begin{verbatim}
     /\cpalavra
\end{verbatim}

Usando \verb|\c| o Vim encontrará ``{\em{palavra}}'', ``{\em{Palavraa}}'' ou
até mesmo ``{\em{PALAVRA}}''. Uma dica é colocar no seu arquivo de configuração
``vimrc'' veja o capítulo \ref{cha:Como editar preferências no Vim} na
página~\pageref{cha:Como editar preferências no Vim}.

\begin{verbatim}
     set ignorecase .. ignora maiúsculas e minúsculas na bucsca
     set smartcase ... se busca contiver maiúsculas ele passa a 
                       considerá-las
     set hlsearch .... mostra o que está sendo buscado em cores
     set incsearch ... ativa a busca incremental
\end{verbatim}

se você não sabe ainda como colocar estas preferências no arquivo de configuração pode
ativa-las em modo de comando precedendo-as com dois pontos, assim:

\begin{verbatim}
     :set ignorecase<Enter>
\end{verbatim}

Substituições com confirmação:

\begin{verbatim}
     :%s/word/palavra/c ..... o `c' no final habilita a confirmação
\end{verbatim}


Procurando palavras repetidas

\begin{verbatim}
     /\<\(\w*\) \1\>
\end{verbatim}

Multilinha

\begin{verbatim}
     /Hello\_s\+World
\end{verbatim}

Buscará `World', separado por qualquer número de espaços,
incluindo quebras de linha. Buscará as três sequências:

\begin{verbatim}
     Hello World

     Hello    World

     Hello
     World
\end{verbatim}

Buscar linhas de até 30 caracteres de comprimento

\begin{verbatim}
     /^.\{,30\}$
\end{verbatim}

\begin{verbatim}
     ^  ..... representa começo de linha
     .  ..... representa qualquer caractere
\end{verbatim}


\begin{verbatim}
     :%s/<[^>]*>//g ... apaga tags HTML/XML
     :%g/^$/d ......... apaga linhas vazias
     :%s/^[\ \t]*\n//g  apaga linhas vazias
\end{verbatim}


Remover duas ou mais linhas vazias entre parágrafos diminuindo para
uma só linha vazia.

\begin{verbatim}
     :%s/\(^\n\{2,}\)/\r/g
\end{verbatim}

Você pode criar um mapeamento e colocar no seu {\tt ~/.vimrc}

\begin{verbatim}
     map ,s <Esc>:%s/\(^\n\{2,}\)/\r/g<cr>
\end{verbatim}

No exemplo acima, `{\tt ,s}' é um mapeamento para reduzir linhas em branco
sucessivas para uma só  \\


Remove não dígitos (não pega números)

\begin{verbatim}
     :%s/^\D.*//g
\end{verbatim}

Remove final de linha DOS/Windows \verb|^M| que tem código hexadecimal igual a
`{\tt 0d}'

\begin{verbatim}
     :%s/\%x0d//g
\end{verbatim}

Troca palavras de lugar usando expressões regulares:

\begin{verbatim}
     :%s/\(.\+\)\s\(.\+\)/\2 \1/
\end{verbatim}

Modificando todas as tags HTML para minúsculo:

\begin{verbatim}
     :%s/<\([^>]*\)>/<\L\1>/g
\end{verbatim}

Move linhas 10 a 12 para além da linha 30:

\begin{verbatim}
     :10,12m30
\end{verbatim}

\section{O comando global ``g''}\label{sec:O comando global ``g''}

Buscando um padrão e gravando em outro arquivo:

\begin{verbatim}
     :'a,'b g/^Error/ . w >> errors.txt
\end{verbatim}

Apenas imprimir linhas que contém determinada palavra, isto é útil
quando você quer ter uma visão sobre um determina aspecto
do seu arquivo vejamos:

\begin{verbatim}
     :set nu ..... habilita numeração
     :g/Error/p .. apenas mostra as linhas correspondentes
\end{verbatim}

{\Large \ding{45}} Para mostrar o as linhas correspondentes a um padrão, mesmo que 
a numeração de linha não esteja habilitada use ``{\tt :g/padrão/\#}''.

numerar linhas:

\begin{verbatim}
     :let i=1 | g/^/s//\=i."\t"/ | let i=i+1
\end{verbatim}

Outro modo de inserir números de linha

\begin{verbatim}
    :%s/^/\=line('.').'  '

    : ............ comando
    % ............ em todo o arquivo
    s ............ substituição
    / ............ inicio da busca
    ^ ............ começo de linha
    / ............ inicio da substituição
    \=line('.') .. corresponde ao nº da linha atual
    .'  ' ........ concatena um espaço após o nº
\end{verbatim}


Para copiar linhas começadas com {\em Error} para o final do arquivo faça:

\begin{verbatim}
     :g/^Error/ copy $
\end{verbatim}

Obs: O comando `{\tt copy}' pode ser abreviado `{\tt co}' ou ainda pode-se usar `{\tt t}'
para mais detalhes:

\begin{verbatim}
     :h co
\end{verbatim}

Como adicionar um padrão copiado com `{\tt yy}' após um determinado padrão?

\begin{verbatim}
    :g/padrao/+put!
    :g/padrao/.put='teste'
\end{verbatim}

Entre as linhas que contiverem `{\tt fred}' e `{\tt joe}' substitua:

\begin{verbatim}
     :g/fred/,/joe/s/isto/aquilo/gic
\end{verbatim}

As opções `gic' correspondem a {\em global}, {\em ignore case} e {\em
confirm}, podendo ser omitidas deixando só o {\em global}. \\


Pegar caracteres numéricos e jogar no final do arquivo:

\begin{verbatim}
     :g/^\d\+.*/m $
\end{verbatim}

Inverter a ordem das linhas do arquivo:

\begin{verbatim}
     :g/^/m0
\end{verbatim}

Apagar as linhas que contém {\tt Line commented}:

\begin{verbatim}
     :g/Line commented/d
\end{verbatim}

Apagar todas as linhas comentadas

\begin{verbatim}
      :g/^\s*#/d
\end{verbatim}

Copiar determinado padrão para um registro:

\begin{verbatim}
     :g/pattern/ normal "Ayy
\end{verbatim}

Copiar linhas que contém um padrão e a linha subsequente para o final:

\begin{verbatim}
     :g/padrão/;+1 copy $
\end{verbatim}

Deletar linhas que não contenham um padrão:

\begin{verbatim}
     :v/dicas/d  ..... deleta linhas que não contenham `dicas'
\end{verbatim}

Incrementar números no começo da linha:

\index{numeros!incrementar}
\begin{verbatim}
     :.,20g/^\d/exe "normal! \<c-a>"
\end{verbatim}

Sublinhar linhas começadas com {\em Chapter}:

\begin{verbatim}
     :g/^Chapter/t.|s/./-/g

     : ........ comando
     g ........ global
     / ........ inicio de um padrão
     ^ ........ começo de linha
     Chapter .. palavra literal
     / ........ fim do parão
     t ........ copia
     . ........ linha atual
     s ........ substitua
     / ........ inicio de um padrão
     . ........ qualquer caractere
     / ........ início da substituição
     - ........ por traço
     / ........ fim da substituição
     g ........ em todas as ocorrências
\end{verbatim}

\section{Dicas }
Para colocar a última busca em uma substituição faça:

\begin{verbatim}
     :%s/Ctrl-r//novo/g
\end{verbatim}

A dupla barra corresponde ao ultimo padrão procurado, e portanto o
comando abaixo fará a substituição da ultima busca por casinha:

\begin{verbatim}
     :%s//casinha/g
\end{verbatim}

\section{Filtrando arquivos com o vimgrep}
\label{Filtrando arquivos com o vimgrep}

Por vezes sabemos que aquela anotação foi feita, mas no momento esquecemos em qual
arquivo está, no exemplo abaixo procuramos a palavra dicas à partir da nossa pasta pessoal
pela palavra `dicas' em todos os arquivos com extensão `{\tt txt}'.

\begin{verbatim}
     ~/ ............ equivale a /home/user
     :lvimgrep /dicas/gj ~/**/*.txt | ls
     :vimgrep /dicas/gj **/*.txt | copen
     :vimgrep dicas **/*.txt | copen
     :h lvim ....... ajuda sobre o comando
\end{verbatim}



\section{Copiar a partir de um ponto}

\begin{verbatim}
     :19;+3 co $
\end{verbatim}

O Vim sempre necessita de um intervalo (inicial e final) mas se usar-mos
`;' ele considera a primeira linha como segundo ponto do
intervalo, e no caso acima estamos dizendo (nas entrelinhas) linhas
19 e 19+3     \\


De forma análoga pode-se usar como referência um padrão qualquer:

\begin{verbatim}
     :/palavra/;+10 m 0
\end{verbatim}

O comando acima diz: à partir da linha que contém ``palavra'' incluindo as 10 próximas linhas
mova `{\tt m}' para a primeira linha `0', ou seja, antes da linha 1.

\section{Dicas das lista vi-br}

Fonte: \href{http://groups.yahoo.com/group/vi-br/message/853}{Grupo vi-br do
yahoo}~\cite{ViBr01}

Problema:
Essa deve ser uma pergunta comum.
Suponha o seguinte conteúdo de arquivo:

\begin{verbatim}
     ... // várias linhas
     texto1000texto    // linha i
     texto1000texto    // linha i+1
     texto1000texto    // linha i+2
     texto1000texto    // linha i+3
     texto1000texto    // linha i+4
     ... // várias linhas
\end{verbatim}

Gostaria de um comando que mudasse para

\begin{verbatim}
     ... // várias linhas
     texto1001texto    // linha i
     texto1002texto    // linha i+1
     texto1003texto    // linha i+2
     texto1004texto    // linha i+3
     texto1005texto    // linha i+4
     ... // várias linhas
\end{verbatim}

Ou seja, somasse 1 a cada um dos números entre os textos
especificando como range as linhas i,i+4

\begin{verbatim}
     :10,20! awk 'BEGIN{i=1}{if (match($0, ``+'')) print ``o''
     (substr($0, RSTART, RLENGTH) + i++) ``o'``}''
\end{verbatim}

Mas muitos sistemas não tem {\tt awk}, e logo a melhor solução mesmo é usar o Vim:

\begin{verbatim}
     :let i=1 | 10,20 g/texto\d\+texto/s/\d\+/\=submatch(0)+i/ | let i=i+1
\end{verbatim}

Observação: 10,20 é o intervalo, ou seja, da linha 10 até a linha 20

\begin{verbatim}
     :help /
     :help :s
     :help pattern
\end{verbatim}

{\Large \ding{45}} O plugin \href{http://vim.sourceforge.net/scripts/script.php?script_id=670}{Visincr}~\cite{Visincr}
Possibilita incrementos em modo visual de diversas formas, um vídeo demonstrativos pode ser visto neste 
link: \href{http://vimeo.com/4457161}{http://vimeo.com/4457161}

\section{Junção de linhas com Vim}
\label{sec:Junção de linhas com Vim}
\index{junção de linhas}

Fonte: \href{http://www.dicas-l.com.br/dicas-l/20081228.php}{dicas-l da
unicamp}~\cite{dicas-lJuncaoDeLinhas} \\ Colaboração: Rubens Queiroz de Almeida

Recentemente precisei combinar, em um arquivo, duas linhas
consecutivas. O arquivo original continha linhas como:

\begin{verbatim}
     Matrícula: 123456
     Senha: yatVind7kned
     Matrícula: 123456
     Senha: invanBabnit3
\end{verbatim}

E assim por diante. Eu precisava converter este arquivo para algo como:

\begin{verbatim}
     Matrícula: 123456 - Senha: yatVind7kned
     Matrícula: 123456 - Senha: invanBabnit3
\end{verbatim}

Para isto, basta executar o comando:

\begin{verbatim}
     :g/^Matrícula/s/\n/ - /
\end{verbatim}

Explicando:

\begin{verbatim}
     s/isto/aquilo/g .. substitui isto por aquilo
     g ................ comando global
     /................. inicia padrão de busca
     ^ ................ indica começo de linha
     Matrícula ........ palavra a ser buscada
     s ................ inicia substituição
     /\n/ - / ......... troca quebra de linha `\n', por `-'
\end{verbatim}

\section{Buscando em um intervalo de linhas} % (fold)
\label{sec:Buscando em um intervalo de linhas}
\index{buscas!intervalo}
Para buscar entre as linhas 10 e 50 por um padrão qualquer fazemos:
\begin{verbatim}
    /padrao\%>10l\$<50l
\end{verbatim}

Esta e outras boas dicas podem ser lidas no site
\href{http://vimdoc.sourceforge.net/htmldoc/vimfaq.html}{vim-faq}~\cite{VimFaq}.
% section Buscando em um intervalo de linh (end)

